﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace GitTool
{
    public class MD5_Tool
    {
        /// <summary>
        /// 计算gitDir目录下所有文件的MD5值信息，保存为文件
        /// </summary>
        public static void GenGitMD5(string gitDir, string gitUrl)
        {
            if (!System.IO.Directory.Exists(gitDir)) return;

            string[] files = GetGitFiles(gitDir);   // 除.Git外的文件和目录信息
            string data = GetMD5(files);            // 计算所有文件MD5值信息

            if (!gitDir.EndsWith("\\")) gitDir = gitDir + "\\";
            data = data.Replace(gitDir, "");
            data = data.Replace("\\", "/");
            if (gitUrl.EndsWith(".git")) gitUrl = gitUrl.Substring(0, gitUrl.LastIndexOf(".git"));

            data = "服务器资源目录(" + gitUrl + "/raw/master/)\r\n本地资源目录(" + gitDir + ")\r\n\r\n待更新文件(\r\n" + data;
            data = data + "\r\n\r\n)待更新文件\r\n";

            SaveProcess(data, "", gitDir, Encoding.UTF8);
        }

        /// <summary>
        /// 生成文件列表信息html
        /// </summary>
        public static void GenGitFileHtml(string gitDir, string gitUrl)
        {
            if (!System.IO.Directory.Exists(gitDir)) return;

            string[] FileDir = GetGitFiles(gitDir);         // 除.Git外的文件和目录信息
            string filesNames = toSubDirFileNames(FileDir); // 获取文件和目录下所有文件
            string[] subFiles = filesNames.Split(';');

            // 服务器资源目录
            if (gitUrl.EndsWith(".git")) gitUrl = gitUrl.Substring(0, gitUrl.LastIndexOf(".git"));
            string name = gitUrl.Substring(gitUrl.LastIndexOf("/") + 1);
            string serverUrl = gitUrl + "/raw/master/";

            // 本地资源目录
            if (!gitDir.EndsWith("\\")) gitDir = gitDir + "\\";

            // 生成文件列表信息
            StringBuilder htmlData = new StringBuilder();
            htmlData.AppendLine("<!DOCTYPE html>");
            htmlData.AppendLine("<html lang=\"zh-CN\">");
            htmlData.AppendLine("");
            htmlData.AppendLine("<head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">");

            htmlData.AppendLine("<title>" + name + "文件列表</title>");
            htmlData.AppendLine("</head>");
            htmlData.AppendLine("");
            htmlData.AppendLine("<body>");
            htmlData.AppendLine("<div>");

            foreach (string file in subFiles)
            {
                string relative = file.Replace(gitDir, "").Replace("\\", "/");
                string href = serverUrl + relative;
                string iteam = "<p style=\"text-align:justify\"> <a target=\"_blank\" href=\"" + href + "\">" + relative + "</a></p>";
                htmlData.AppendLine(iteam);
            }

            htmlData.AppendLine("</div>");
            htmlData.AppendLine("</body>");
            htmlData.AppendLine("");
            htmlData.AppendLine("</html>");

            // 保存至文件
            SaveProcess(htmlData.ToString(), "index.html", gitDir, Encoding.UTF8);
        }

        /// <summary>
        /// 获取Git目录下，除.git目录外的文件和目录信息
        /// </summary>
        private static string[] GetGitFiles(string gitDir)
        {
            List<string> list = new List<string>();

            // 所有文件信息
            string[] files = System.IO.Directory.GetFiles(gitDir);
            foreach (string file in files) if (!file.EndsWith("\\MD5.txt") && !file.EndsWith("\\index.html")) list.Add(file);

            // 所有子目录名  
            string[] Dirs = System.IO.Directory.GetDirectories(gitDir);
            foreach (string dir in Dirs) if (!dir.EndsWith("\\.git")) list.Add(dir);

            return list.ToArray();
        }


        #region 文件读取与保存

        /// <summary>  
        /// 获取文件中的数据串  
        /// </summary>  
        public static string fileToString(String filePath, Encoding encoding = null)
        {
            string str = "";

            //获取文件内容  
            if (System.IO.File.Exists(filePath))
            {
                if (encoding == null) encoding = Encoding.Default;
                System.IO.StreamReader file1 = new System.IO.StreamReader(filePath, encoding);//读取文件中的数据  
                str = file1.ReadToEnd();                                            //读取文件中的全部数据  

                file1.Close();
                file1.Dispose();
            }
            return str;
        }

        /// <summary>
        /// 保存数据data到文件处理过程，返回值为保存的文件名
        /// </summary>  
        public static String SaveProcess(String data, String name = "", String CurDir = "", Encoding encoding = null)
        {
            if (CurDir.Equals("")) CurDir = System.AppDomain.CurrentDomain.BaseDirectory;           //设置当前目录  
            if (name.Equals("")) name = "MD5.txt";
            if (!System.IO.Directory.Exists(CurDir)) System.IO.Directory.CreateDirectory(CurDir);   //该路径不存在时，在当前文件目录下创建文件夹"导出.."  

            //不存在该文件时先创建  
            String filePath = CurDir + name;
            if (encoding == null) encoding = Encoding.Default;
            System.IO.StreamWriter file1 = new System.IO.StreamWriter(filePath, false, encoding);   //文件已覆盖方式添加内容  

            file1.Write(data);                                                              //保存数据到文件  

            file1.Close();                                                                  //关闭文件  
            file1.Dispose();                                                                //释放对象  

            return filePath;
        }

        #endregion


        #region 文件读取与保存

        /// <summary>
        /// 获取文件、或目录下所有文件的MD5值信息
        /// </summary>
        public static string GetMD5(Array FileDir)
        {
            string filesNames = toSubDirFileNames(FileDir); // 获取文件和目录下所有文件
            string[] subFiles = filesNames.Split(';');

            string tmp = getFilesMD5(subFiles);             // 计算文件MD5值
            return tmp;
        }

        // 计算各文件对应的MD5值
        public static String getFilesMD5(string[] files)
        {
            string tmp = "";

            foreach (string file in files)
            {
                if (System.IO.File.Exists(file))
                {
                    string data = fileToString(file);
                    string md5 = MD5.Encrypt(data, 32);
                    tmp += "\r\n" + file + "(" + md5 + ")";
                }
            }

            return tmp;
        }

        // 获取所有files目录下的所有文件，转化为单个串
        public static string toSubDirFileNames(Array files)
        {
            StringBuilder filesName = new StringBuilder("");

            foreach (object I in files)
            {
                string str = I.ToString();

                System.IO.FileInfo info = new System.IO.FileInfo(str);
                //若为目录，则获取目录下所有子文件名  
                if ((info.Attributes & System.IO.FileAttributes.Directory) != 0)
                {
                    str = getAllFiles(str);
                    if (!str.Equals("")) filesName.Append((filesName.Length == 0 ? "" : ";") + str);
                }
                //若为文件，则获取文件名  
                else if (System.IO.File.Exists(str))
                    filesName.Append((filesName.Length == 0 ? "" : ";") + str);
            }

            return filesName.ToString();
        }

        /// <summary>  
        /// 判断path是否为目录  
        /// </summary>  
        public bool IsDirectory(String path)
        {
            System.IO.FileInfo info = new System.IO.FileInfo(path);
            return (info.Attributes & System.IO.FileAttributes.Directory) != 0;
        }

        /// <summary>  
        /// 获取目录path下所有子文件名  
        /// </summary>  
        public static string getAllFiles(String path)
        {
            StringBuilder str = new StringBuilder("");
            if (System.IO.Directory.Exists(path))
            {
                //所有子文件名  
                string[] files = System.IO.Directory.GetFiles(path);
                foreach (string file in files)
                    str.Append((str.Length == 0 ? "" : ";") + file);

                //所有子目录名  
                string[] Dirs = System.IO.Directory.GetDirectories(path);
                foreach (string dir in Dirs)
                {
                    string tmp = getAllFiles(dir);  //子目录下所有子文件名  
                    if (!tmp.Equals("")) str.Append((str.Length == 0 ? "" : ";") + tmp);
                }
            }
            return str.ToString();
        }

        #endregion

    }

    //示例： MD5.Encrypt("", 32);  

    //MD5 ("") = d41d8cd98f00b204e9800998ecf8427e   
    //MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661   
    //MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72   
    //MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0   
    //MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b  
    public class MD5
    {
        const int NUM_8 = 8;
        const int NUM_4 = 4;
        const int NUM_32 = 32;
        private static long[] m_lOnBits = new long[30 + 1];
        private static long[] m_l2Power = new long[30 + 1];
        private static long LShift(long lValue, long iShiftBits)
        {
            long LShift = 0;
            if (iShiftBits == 0)
            {
                LShift = lValue;
                return LShift;
            }
            else
            {
                if (iShiftBits == 31)
                {
                    if (Convert.ToBoolean(lValue & 1))
                    {
                        LShift = 0x80000000;
                    }
                    else
                    {
                        LShift = 0;
                    }
                    return LShift;
                }
                else
                {
                    if (iShiftBits < 0 || iShiftBits > 31)
                    {
                        // Err.Raise 6;     
                    }
                }
            }
            if (Convert.ToBoolean((lValue & m_l2Power[31 - iShiftBits])))
            {
                LShift = ((lValue & m_lOnBits[31 - (iShiftBits + 1)]) * m_l2Power[iShiftBits]) | 0x80000000;
            }
            else
            {
                LShift = ((lValue & m_lOnBits[31 - iShiftBits]) * m_l2Power[iShiftBits]);
            }
            return LShift;
        }
        private static long RShift(long lValue, long iShiftBits)
        {
            long RShift = 0;
            if (iShiftBits == 0)
            {
                RShift = lValue;
                return RShift;
            }
            else
            {
                if (iShiftBits == 31)
                {
                    if (Convert.ToBoolean(lValue & 0x80000000))
                    {
                        RShift = 1;
                    }
                    else
                    {
                        RShift = 0;
                    }
                    return RShift;
                }
                else
                {
                    if (iShiftBits < 0 || iShiftBits > 31)
                    {
                        // Err.Raise 6;     
                    }
                }
            }
            RShift = (lValue & 0x7FFFFFFE) / m_l2Power[iShiftBits];
            if (Convert.ToBoolean((lValue & 0x80000000)))
            {
                RShift = (RShift | (0x40000000 / m_l2Power[iShiftBits - 1]));
            }
            return RShift;
        }
        private static long RotateLeft(long lValue, long iShiftBits)
        {
            long RotateLeft = 0;
            RotateLeft = LShift(lValue, iShiftBits) | RShift(lValue, (32 - iShiftBits));
            return RotateLeft;
        }
        private static long AddUnsigned(long lX, long lY)
        {
            //return (lX & 0x3FFFFFFF + lY & 0x3FFFFFFF) & 0x3FFFFFFF;
            long AddUnsigned = 0;
            long lX4 = 0;
            long lY4 = 0;
            long lX8 = 0;
            long lY8 = 0;
            long lResult = 0;
            lX8 = lX & 0x80000000;
            lY8 = lY & 0x80000000;
            lX4 = lX & 0x40000000;
            lY4 = lY & 0x40000000;
            lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
            if (Convert.ToBoolean(lX4 & lY4))
            {
                lResult = lResult ^ 0x80000000 ^ lX8 ^ lY8;
            }
            else if (Convert.ToBoolean(lX4 | lY4))
            {
                if (Convert.ToBoolean(lResult & 0x40000000))
                {
                    lResult = lResult ^ 0xC0000000 ^ lX8 ^ lY8;
                }
                else
                {
                    lResult = lResult ^ 0x40000000 ^ lX8 ^ lY8;
                }
            }
            else
            {
                lResult = lResult ^ lX8 ^ lY8;
            }
            AddUnsigned = lResult;
            return AddUnsigned;
        }
        private static long md5_F(long x, long y, long z)
        {
            long md5_F = 0;
            md5_F = (x & y) | ((~x) & z);
            return md5_F;
        }
        private static long md5_G(long x, long y, long z)
        {
            long md5_G = 0;
            md5_G = (x & z) | (y & (~z));
            return md5_G;
        }
        private static long md5_H(long x, long y, long z)
        {
            // 0^0^0 = 0
            // 0^0^1 = 1
            // 0^1^0 = 1
            // 0^1^1 = 0
            // 1^0^0 = 1
            // 1^0^1 = 0
            // 1^1^0 = 0
            // 1^1^1 = 1
            long md5_H = 0;
            md5_H = (x ^ y ^ z);
            return md5_H;
        }
        private static long md5_I(long x, long y, long z)
        {
            long md5_I = 0;
            md5_I = (y ^ (x | (~z)));
            //md5_I = ((y ^ x) & (y ^ (~z))) | ((~y) ^ ((~x) & (~z)));
            return md5_I;
        }
        private static void md5_FF(ref long a, long b, long c, long d, long x, long s, long ac)
        {
            //a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_F(b, c, d), x), ac));
            //a = RotateLeft(a, s);
            //a = AddUnsigned(a, b);

            long f = md5_F(b, c, d);

            long tmp = AddUnsigned(x, ac);
            tmp = AddUnsigned(tmp, a);
            tmp = AddUnsigned(tmp, f);
            a = tmp;

            a = RotateLeft(a, s);
            a = AddUnsigned(a, b);
        }
        private static void md5_GG(ref long a, long b, long c, long d, long x, long s, long ac)
        {
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_G(b, c, d), x), ac));
            a = RotateLeft(a, s);
            a = AddUnsigned(a, b);
        }
        private static void md5_HH(ref long a, long b, long c, long d, long x, long s, long ac)
        {
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_H(b, c, d), x), ac));
            a = RotateLeft(a, s);
            a = AddUnsigned(a, b);
        }
        private static void md5_II(ref long a, long b, long c, long d, long x, long s, long ac)
        {
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_I(b, c, d), x), ac));
            a = RotateLeft(a, s);
            a = AddUnsigned(a, b);
        }
        private static long[] ConvertToWordArray(string sMessage)
        {
            long[] ConvertToWordArray = null;
            int lMessageLength = 0;
            int lNumberOfWords = 0;
            long[] lWordArray = null;
            int lBytePosition = 0;
            int lByteCount = 0;
            int lWordCount = 0;
            const int MODULUS_BITS = 512;
            const int CONGRUENT_BITS = 448;

            byte[] Array = System.Text.Encoding.Default.GetBytes(sMessage);
            lMessageLength = Array.Length;

            lNumberOfWords = (((lMessageLength + ((MODULUS_BITS - CONGRUENT_BITS) / NUM_8)) / (MODULUS_BITS / NUM_8)) + 1) * (MODULUS_BITS / NUM_32);
            lWordArray = new long[lNumberOfWords];
            lBytePosition = 0;
            lByteCount = 0;
            while (lByteCount < lMessageLength)
            {
                lWordCount = lByteCount / NUM_4;
                lBytePosition = (lByteCount % NUM_4) * NUM_8;
                lWordArray[lWordCount] = lWordArray[lWordCount] | LShift(Array[lByteCount], lBytePosition);
                lByteCount = lByteCount + 1;
            }
            lWordCount = lByteCount / NUM_4;
            lBytePosition = (lByteCount % NUM_4) * NUM_8;
            lWordArray[lWordCount] = lWordArray[lWordCount] | LShift(0x80, lBytePosition);
            lWordArray[lNumberOfWords - 2] = LShift(lMessageLength, 3);
            lWordArray[lNumberOfWords - 1] = RShift(lMessageLength, 29);
            ConvertToWordArray = lWordArray;
            return ConvertToWordArray;
        }
        private static string WordToHex(long lValue)
        {
            string WordToHex = "";
            long lByte = 0;
            int lCount = 0;
            int startIndex = 0;
            for (lCount = 0; lCount <= 3; lCount++)
            {
                lByte = RShift(lValue, lCount * NUM_8) & m_lOnBits[NUM_8 - 1];
                startIndex = ("0" + ToHex(lByte)).Length - 2;
                WordToHex = WordToHex + (("0" + ToHex(lByte)).Substring(startIndex < 0 ? 0 : startIndex));
            }
            return WordToHex;
        }
        private static string ToHex(long dec)
        {
            string strhex = "";
            while (dec > 0)
            {
                strhex = tohex(dec % 16) + strhex;
                dec = dec / 16;
            }
            return strhex;
        }
        private static string tohex(long hex)
        {
            string strhex = "";
            switch (hex)
            {
                case 10: strhex = "a"; break;
                case 11: strhex = "b"; break;
                case 12: strhex = "c"; break;
                case 13: strhex = "d"; break;
                case 14: strhex = "e"; break;
                case 15: strhex = "f"; break;
                default: strhex = hex.ToString(); break;
            }
            return strhex;
        }

        public static string Encrypt(string sMessage, int stype)
        {
            string MD5 = "";
            for (int i = 0; i <= 30; i++)
            {
                m_lOnBits[i] = Convert.ToInt64(Math.Pow(2, i + 1) - 1);
                m_l2Power[i] = Convert.ToInt64(Math.Pow(2, i));
            }
            long[] x = null;
            int k = 0;
            long AA = 0;
            long BB = 0;
            long CC = 0;
            long DD = 0;
            long a = 0;
            long b = 0;
            long c = 0;
            long d = 0;
            const int S11 = 7;
            const int S12 = 12;
            const int S13 = 17;
            const int S14 = 22;
            const int S21 = 5;
            const int S22 = 9;
            const int S23 = 14;
            const int S24 = 20;
            const int S31 = 4;
            const int S32 = 11;
            const int S33 = 16;
            const int S34 = 23;
            const int S41 = 6;
            const int S42 = 10;
            const int S43 = 15;
            const int S44 = 21;
            x = ConvertToWordArray(sMessage);
            a = 0x67452301;
            b = 0xEFCDAB89;
            c = 0x98BADCFE;
            d = 0x10325476;
            for (k = 0; k < x.Length; k += 16)
            {
                AA = a;
                BB = b;
                CC = c;
                DD = d;
                md5_FF(ref a, b, c, d, x[k + 0], S11, 0xD76AA478);
                md5_FF(ref d, a, b, c, x[k + 1], S12, 0xE8C7B756);
                md5_FF(ref c, d, a, b, x[k + 2], S13, 0x242070DB);
                md5_FF(ref b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
                md5_FF(ref a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
                md5_FF(ref d, a, b, c, x[k + 5], S12, 0x4787C62A);
                md5_FF(ref c, d, a, b, x[k + 6], S13, 0xA8304613);
                md5_FF(ref b, c, d, a, x[k + 7], S14, 0xFD469501);
                md5_FF(ref a, b, c, d, x[k + 8], S11, 0x698098D8);
                md5_FF(ref d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
                md5_FF(ref c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
                md5_FF(ref b, c, d, a, x[k + 11], S14, 0x895CD7BE);
                md5_FF(ref a, b, c, d, x[k + 12], S11, 0x6B901122);
                md5_FF(ref d, a, b, c, x[k + 13], S12, 0xFD987193);
                md5_FF(ref c, d, a, b, x[k + 14], S13, 0xA679438E);
                md5_FF(ref b, c, d, a, x[k + 15], S14, 0x49B40821);
                md5_GG(ref a, b, c, d, x[k + 1], S21, 0xF61E2562);
                md5_GG(ref d, a, b, c, x[k + 6], S22, 0xC040B340);
                md5_GG(ref c, d, a, b, x[k + 11], S23, 0x265E5A51);
                md5_GG(ref b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
                md5_GG(ref a, b, c, d, x[k + 5], S21, 0xD62F105D);
                md5_GG(ref d, a, b, c, x[k + 10], S22, 0x2441453);
                md5_GG(ref c, d, a, b, x[k + 15], S23, 0xD8A1E681);
                md5_GG(ref b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
                md5_GG(ref a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
                md5_GG(ref d, a, b, c, x[k + 14], S22, 0xC33707D6);
                md5_GG(ref c, d, a, b, x[k + 3], S23, 0xF4D50D87);
                md5_GG(ref b, c, d, a, x[k + 8], S24, 0x455A14ED);
                md5_GG(ref a, b, c, d, x[k + 13], S21, 0xA9E3E905);
                md5_GG(ref d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
                md5_GG(ref c, d, a, b, x[k + 7], S23, 0x676F02D9);
                md5_GG(ref b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
                md5_HH(ref a, b, c, d, x[k + 5], S31, 0xFFFA3942);
                md5_HH(ref d, a, b, c, x[k + 8], S32, 0x8771F681);
                md5_HH(ref c, d, a, b, x[k + 11], S33, 0x6D9D6122);
                md5_HH(ref b, c, d, a, x[k + 14], S34, 0xFDE5380C);
                md5_HH(ref a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
                md5_HH(ref d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
                md5_HH(ref c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
                md5_HH(ref b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
                md5_HH(ref a, b, c, d, x[k + 13], S31, 0x289B7EC6);
                md5_HH(ref d, a, b, c, x[k + 0], S32, 0xEAA127FA);
                md5_HH(ref c, d, a, b, x[k + 3], S33, 0xD4EF3085);
                md5_HH(ref b, c, d, a, x[k + 6], S34, 0x4881D05);
                md5_HH(ref a, b, c, d, x[k + 9], S31, 0xD9D4D039);
                md5_HH(ref d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
                md5_HH(ref c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
                md5_HH(ref b, c, d, a, x[k + 2], S34, 0xC4AC5665);
                md5_II(ref a, b, c, d, x[k + 0], S41, 0xF4292244);
                md5_II(ref d, a, b, c, x[k + 7], S42, 0x432AFF97);
                md5_II(ref c, d, a, b, x[k + 14], S43, 0xAB9423A7);
                md5_II(ref b, c, d, a, x[k + 5], S44, 0xFC93A039);
                md5_II(ref a, b, c, d, x[k + 12], S41, 0x655B59C3);
                md5_II(ref d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
                md5_II(ref c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
                md5_II(ref b, c, d, a, x[k + 1], S44, 0x85845DD1);
                md5_II(ref a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
                md5_II(ref d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
                md5_II(ref c, d, a, b, x[k + 6], S43, 0xA3014314);
                md5_II(ref b, c, d, a, x[k + 13], S44, 0x4E0811A1);
                md5_II(ref a, b, c, d, x[k + 4], S41, 0xF7537E82);
                md5_II(ref d, a, b, c, x[k + 11], S42, 0xBD3AF235);
                md5_II(ref c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
                md5_II(ref b, c, d, a, x[k + 9], S44, 0xEB86D391);
                a = AddUnsigned(a, AA);
                b = AddUnsigned(b, BB);
                c = AddUnsigned(c, CC);
                d = AddUnsigned(d, DD);
            }
            if (stype == 32)
            {
                MD5 = ((((WordToHex(a)) + (WordToHex(b))) + (WordToHex(c))) + (WordToHex(d))).ToLower();
            }
            else
            {
                MD5 = ((WordToHex(b)) + (WordToHex(c))).ToLower();
            }
            return MD5;
        }

    }     

}
